package io.renren.common.utils;

import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

/**
 * 字符串工具类
 */
public class StringUtils {
    /**
     * 检查对象转换成数字
     *
     * @param value
     * @return
     */
    public static String checkObjForNum(Object value) {
        if (value == null || value.toString().trim().equals("")) {
            value = "0";
        }
        return value.toString().trim();
    }

    /**
     * 检查对象转换成字符
     *
     * @param value
     * @return
     */
    public static String checkObj2Str(Object value) {
        if (value == null || value.toString().trim().equals("")) {
            value = "";
        }
        return value.toString().trim();
    }

    /**
     * 检查对象转换成字符
     *
     * @param value
     * @param defaultValue 如果为null或者空字符串须返回的默认值
     * @return
     */
    public static String checkObj2Str(Object value, Object defaultValue) {
        if (value == null || value.toString().trim().equals("")) {
            value = defaultValue;
        }
        return value.toString().trim();
    }

    /**
     * 给字符串左边补0
     *
     * @param str    要进行补0操作的字符串
     * @param length 要补到的位数
     * @return 补充完的字符串 如字符串st="789",length=10,则方法返回为"0000000789"
     */
    public static String supplementZero(String str, int length) {
        StringBuffer zero = new StringBuffer();
        if ((length - str.length()) > 0) {
            for (int i = 0; i < (length - str.length()); i++) {
                zero.append("0");
            }
        }
        return zero.append(str).toString();
    }

    /**
     * 给字符串左边补0
     *
     * @param obj    要进行补0操作的对象
     * @param length 要补到的位数
     * @return 补充完的字符串 如字符串st="789",length=10,则方法返回为"0000000789"
     */
    public static String supplementZero(Object obj, int length) {
        String str = checkObj2Str(obj);
        return supplementZero(str, length);
    }

    /**
     * 判断对象是否为NULL或空字符串
     *
     * @param obj
     * @return
     */
    public static boolean isEmpty(Object obj) {
        if ("".equals(checkObj2Str(obj))) {
            return true;
        }
        return false;
    }

    /**
     * 判断对象是否不为NULL或空字符串
     *
     * @param obj
     * @return
     */
    public static boolean isNotEmpty(Object obj) {
        if ("".equals(checkObj2Str(obj))) {
            return false;
        }
        return true;
    }

    /**
     * 字符串数组去重
     *
     * @param strArray
     * @return
     */
    public static String[] arrayUnique(String[] strArray) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < strArray.length; i++) {
            if (!list.contains(strArray[i].trim())) {
                list.add(strArray[i].trim());
            }
        }
        return (String[]) list.toArray(new String[list.size()]);
    }

    /**
     * 字符串数组转换成字符串
     *
     * @param strArray
     * @param seq
     * @return
     */
    public static String join(Object[] strArray, String seq) {
        return org.apache.commons.lang3.StringUtils.join(strArray, seq);
    }

    /**
     * 集合中元素去重
     *
     * @param list
     * @return
     */
    public static List<String> removeDuplicate(List<String> list) {
        if (StringUtils.isEmpty(list)) {
            return list;
        }
        HashSet<String> hs = new HashSet<String>(list);// 此处将list中重复项进行去重
        list = new ArrayList<String>(hs);// 此处将Set集合转成List集合
        return list;
    }

    /**
     * 判断是否不是空白字符串，null/半角/全角空格为无效值
     *
     * @param input
     * @return
     */
    public static boolean isNotBlank(String input) {
        return !isBlank(input);
    }

    /**
     * 判断是否是空白字符串，null/半角/全角空格为无效值
     *
     * @param input
     * @return
     */
    public static boolean isBlank(String input) {
        return isNull(input) || "".equals(input.replaceAll("[\\s　]+", ""));
    }

    /**
     * 判断字符串是否是null
     *
     * @param input
     * @return
     */
    public static boolean isNull(String input) {
        return input == null;
    }

    /**
     * 与String.split()不同的是，此方法会前置校验字符串的有效性，无效则返回空数组
     *
     * @param input     需分割的字符串
     * @param separator 分割符
     * @return
     */
    public static String[] split(String input, String separator) {
        if (isNotEmpty(input)) {
            return input.split(separator);
        }
        return new String[]{};
    }

    /**
     * 截取字符串
     *
     * @param str
     * @param size
     * @return
     */
    public synchronized static String splitString(String str, int size) {
        if (isEmpty(str)) {
            return "";
        }
        if (str.length() > size) {
            return str.substring(0, size) + "...";
        }
        return str;
    }

    /**
     * 从ISO8859-1转换为utf-8
     *
     * @param str
     * @return
     */
    public synchronized static String convert2UTF8FromIOS8859_1(String str) {
        if (isEmpty(str)) {
            return str;
        }
        try {
            return new String(str.getBytes("ISO8859-1"), "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return str;
    }

    /**
     * 从utf-8转换为ISO8859-1
     *
     * @param str
     * @return
     */
    public synchronized static String convert2ISO8859_1FromUTF8(String str) {
        if (isEmpty(str)) {
            return str;
        }
        try {
            return new String(str.getBytes("UTF-8"), "ISO8859-1");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return str;
    }

    /**
     * 判断字符串是否是正整数
     *
     * @param str
     * @return
     */
    public static boolean isPositiveInteger(String str) {
        if (isEmpty(str)) {
            return false;
        }
        return str.matches("[0-9]*");
    }

    /**
     * 得到一个字符串,在另一个字符串中重复出现的次数,区分大小写
     *
     * @param str  原字符串
     * @param temp 计算重复出现的字符串
     * @return
     */
    public static int stringRepeatNum(String str, String temp) {
        Pattern p = Pattern.compile(temp);
        Matcher m = p.matcher(str);
        int i = 0;
        while (m.find()) {
            i++;
        }
        return i;
    }

    /**
     * 根据values值依次替换字符串中的temp选项,区分大小写
     *
     * @param str    原字符串
     * @param temp   被替换的参数
     * @param values 替换值
     * @return 返回替换后的字符串
     */
    public static String replaceStringByValues(String str, String temp, String... values) {
        if (values == null) {
            return str;
        }
        Pattern p = Pattern.compile(temp);
        Matcher m = p.matcher(str);
        int i = 0;
        while (m.find()) {
            if (isEmpty(values[i])) {
                str = str.replaceFirst(temp, "");
            } else {
                str = str.replaceFirst(temp, values[i]);
                i++;
                if (i >= values.length) {
                    break;
                }
            }
        }
        return str;
    }

    /**
     * 判断一个字符串数组里是否包含某个字符串
     *
     * @param temps
     * @param str
     * @return
     */
    public static boolean isContainsStr(String[] temps, String str) {
        if (isEmpty(str)) {
            return false;
        }
        if (temps == null) {
            return false;
        }
        for (String string : temps) {
            if (str.equals(string)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断是否含有特殊字符
     *
     * @param str
     * @return
     */
    public static boolean isSpecialChar(String str) {
        String regEx = "[ _`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？]|\n|\r|\t";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(str);
        return m.find();
    }

    /**
     * 清除掉所有特殊字符
     *
     * @param str
     * @return
     * @throws PatternSyntaxException
     */
    public static String StringFilter(String str) throws PatternSyntaxException {
        // 清除掉所有特殊字符
        String regEx = "[`~!@#$%^&*()+=|{}':;',//[//]<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？]";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(str);
        return m.replaceAll("").trim();
    }

    /**
     * 去除字符串中的空格、回车、换行符、制表符
     *
     * @param str
     * @return
     */
    public static String replaceSpecialStr(String str) {
        if (isNotEmpty(str)) {
            str = str.replaceAll("\\s*|\t|\r|\n", "");
        }
        return str;
    }

    /**
     * 将对象转换为集合
     *
     * @param obj
     * @return
     */
    public static Map<String, Object> objectToMap(Object obj) {
        Map<String, Object> map = new HashMap<>();
        Field[] fields = obj.getClass().getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            fields[i].setAccessible(true);
            try {
                if (fields[i].get(obj) != null) {
                    map.put(fields[i].getName(), fields[i].get(obj));
                }
            } catch (Exception e) {

            }
            fields[i].setAccessible(false);
        }
        return map;
    }
}
